package com.leifeng.demo.utils;

import java.util.*;

/**
 * @ClassName SensitiveWord
 * @Author leimingfeng
 * @Date 2019/2/28 11:31
 * @Description DFA算法实现 https://blog.csdn.net/shengqianfeng/article/details/79572097
 * @Version 1.0
 **/
public class SensitiveWordUtil {

    /**
     * 最小匹配规则，如：敏感词库["中国","中国人"],语句:"我是中国人",匹配结果：我是[中国]人
     */
    public static final int MinMatchType = 1;
    /**
     * 最大匹配规则，如：敏感词库["中国","中国人"],语句:"我是中国人",匹配结果：我是[中国人]
     */
    public static final int MaxMatchType = 2;

    /**
     * 敏感词汇集合
     */
    public static HashMap sensitiveWordMap;


    /**
     * 初始化敏感词库，构建DFA算法模型
     *
     * @param sensitiveWordSet 敏感词库
     */
    public static synchronized void init(Set<String> sensitiveWordSet) {
        initSensitiveWordMap(sensitiveWordSet);
    }

    /**
     * 初始化敏感词库，构建DFA算法模型
     *
     * @param sensitiveWordSet 敏感词库
     */
    private static void initSensitiveWordMap(Set<String> sensitiveWordSet) {
        // 初始化敏感词库容器，减少扩容操作
        sensitiveWordMap = new HashMap(sensitiveWordSet.size());
        String key;
        Map nowMap;
        Map<String, String> newWordMap;
        Iterator<String> iterator = sensitiveWordSet.iterator();
        while (iterator.hasNext()) {
            // 关键词
            key = iterator.next();
            nowMap = sensitiveWordMap;
            for (int i = 0; i < key.length(); i++) {
                // 转换为char
                char keyChar = key.charAt(i);
                // 从库中获取关键字
                Object wordMap = nowMap.get(keyChar);
                // 如果存在该key,直接赋值，用于下个循环获取
                if (wordMap != null) {
                    nowMap = (Map) wordMap;
                } else {
                    // 不存在则构建一个map，同时将isEnd设置为0，因为他不是最后一个
                    newWordMap = new HashMap();
                    // 不是最后一个
                    newWordMap.put("isEnd", "0");
                    nowMap.put(keyChar, newWordMap);
                    nowMap = newWordMap;
                }

                if (i == key.length() - 1) {
                    // 最后一个
                    nowMap.put("isEnd", "1");
                }
            }
        }
    }

    /**
     * 判断文字是否包含敏感字符
     *
     * @param text      输入文字
     * @param matchType 匹配规则 1：最小匹配规则，2.最大匹配规则
     * @return 若包含返回true，否则返回false
     */
    public static boolean contains(String text, int matchType) {
        boolean flag = false;
        for (int i = 0; i < text.length(); i++) {
            int matchFlag = checkSensitiveWord(text, i, matchType);
            // 大于0存在，返回true
            if (matchFlag > 0) {
                flag = true;
            }
        }
        return flag;
    }


    /**
     * 判断文字是否包含敏感字符
     *
     * @param text 输入文字
     * @return 若包含返回true，否则返回false
     */
    public static boolean contains(String text) {
        return contains(text, MaxMatchType);
    }

    /**
     * 获取文中的敏感词
     *
     * @param text      输入文字
     * @param matchType 匹配规则 1：最小匹配规则，2.最大匹配规则
     * @return 文中包含的关键字集合
     */
    public static Set<String> getSensitiveWord(String text, int matchType) {
        Set<String> sensitiveWordList = new HashSet<>();

        for (int i = 0; i < text.length(); i++) {
            int length = checkSensitiveWord(text, i, matchType);
            // 存在则加入list
            if (length > 0) {
                sensitiveWordList.add(text.substring(i, i + length));
                // 减1的原因，是因为for会自增
                i = i + length - 1;
            }
        }
        return sensitiveWordList;
    }

    /**
     * 获取文中的敏感词
     *
     * @param text 输入文字
     * @return 文中包含的敏感词集合
     */
    public static Set<String> getSensitiveWord(String text) {
        return getSensitiveWord(text, MaxMatchType);
    }

    /**
     * 替换文中的敏感词
     *
     * @param text       输入文字
     * @param matchType  匹配规则 1：最小匹配规则，2.最大匹配规则
     * @param replaceStr 替换的字符，匹配的敏感字以字符逐个替换
     * @return 替换后的内容
     */
    public static String replaceSensitiveWord(String text, String replaceStr, int matchType) {
        String resultText = text;
        // 获取所有敏感词
        StringBuilder str;
        Set<String> set = getSensitiveWord(text, matchType);
        Iterator<String> iterator = set.iterator();
        String word;
        while (iterator.hasNext()) {
            str = new StringBuilder(replaceStr);
            word = iterator.next();
            for (int i = 0; i < word.length()-1; i++) {
                str.append(replaceStr);
            }
            resultText = resultText.replaceAll(word, str.toString());
        }
        return resultText;
    }

    /**
     * 替换文中敏感词
     *
     * @param text       输入文字
     * @param replaceStr 替换后的字符
     * @return 替换后输入内容
     */
    public static String replaceSensitiveWord(String text, String replaceStr) {
        return replaceSensitiveWord(text, replaceStr, MaxMatchType);
    }


    /**
     * 替换文中的敏感词
     *
     * @param text        输入文字
     * @param matchType   匹配规则 1：最小匹配规则，2.最大匹配规则
     * @param replaceChar 替换的字符，匹配的敏感字以字符逐个替换
     * @return 替换后的内容
     */
    public static String replaceSensitiveWord(String text, char replaceChar, int matchType) {
        String resultText = text;
        // 获取所有敏感词
        Set<String> set = getSensitiveWord(text, matchType);
        Iterator<String> iterator = set.iterator();
        String word;
        String replaceStr;
        while (iterator.hasNext()) {
            word = iterator.next();
            replaceStr = getReplaceChars(replaceChar, word.length());
            resultText = resultText.replaceAll(word, replaceStr);
        }
        return resultText;
    }


    /**
     * 替换文中敏感词
     *
     * @param text        输入文字
     * @param replaceChar 替换后的字符
     * @return 替换后输入内容
     */
    public static String replaceSensitiveWord(String text, char replaceChar) {
        return replaceSensitiveWord(text, replaceChar, MaxMatchType);
    }

    private static String getReplaceChars(char replaceChar, int length) {
        String value = String.valueOf(replaceChar);
        for (int i = 0; i < length; i++) {
            value += replaceChar;
        }
        return value;
    }

    /**
     * 检查文字中是否包含敏感字符
     *
     * @param text       输入文字
     * @param beginIndex 开始检索位置
     * @param matchType  匹配规则 1：最小匹配规则，2.最大匹配规则
     * @return 如果存在则返回敏感字符长度，不存在返回0
     */
    private static int checkSensitiveWord(String text, int beginIndex, int matchType) {
        // 敏感词结束标识位，用于敏感词只有1位的情况
        boolean flag = false;
        // 匹配标识数默认为0
        int matchFlag = 0;
        char word;
        Map nowMap = sensitiveWordMap;
        for (int i = beginIndex; i < text.length(); i++) {
            word = text.charAt(i);
            // 获取指定key
            nowMap = (Map) nowMap.get(word);
            // 存在则判断是否为最后一个
            if (nowMap != null) {
                // 找到相应key，匹配标识+1
                matchFlag++;
                // 如果为最后一个匹配规则，结束循环，返回匹配标识数
                if ("1".equals(nowMap.get("isEnd"))) {
                    // 结束位为true
                    flag = true;
                    // 最小规则，直接返回，最大规则还需继续查找
                    if (MinMatchType == matchType) {
                        break;
                    }
                }
            } else {
                // 不存在则直接返回
                break;
            }
        }
        if (matchFlag < 1 || !flag) {
            // 长度必须大于等于1，为词
            matchFlag = 0;
        }
        return matchFlag;
    }
}
